# -*-coding: UTF-8 -*-
from Tkinter import *
from PlancheDeJeu.Joueur import HAUT,BAS,DROITE,GAUCHE
from MiniJeux.FrogMouches.ElementPlateforme import *
from MiniJeux.FrogMouches.JeuDeMouches import *
from ConstantesFrogger import *
import tkFont

try:
    from wPIL import Image, ImageTk, ImageOps
except ImportError:
    try:
        from PIL import Image, ImageTk, ImageOps
    except ImportError:
        import sys
        import tkMessageBox
        tkMessageBox.showwarning("Erreur", "S.V.P. Installez PIL pour jouer sur ce syst�me d'exploitation")
        sys.exit()

class VueJeuDeMouches(Frame):
    def __init__(self, parentGUI, width=600, height=400):
        Frame.__init__(self,parentGUI,width=width, height=height)
        self.root = self
        self.actif = False
        self.largeur=width
        self.hauteur=height
        self.canvas=Canvas(self.root,width=self.largeur, height=self.hauteur, bg='black')

        self.backRaw = Image.open("MiniJeux/FrogMouches/images/background.png")
        if self.largeur > self.hauteur:
            self.backRaw = self.backRaw.resize((self.largeur, self.largeur), Image.ANTIALIAS)
        else:
            self.backRaw = self.backRaw.resize((self.hauteur, self.hauteur), Image.ANTIALIAS)
        self.background = ImageTk.PhotoImage(self.backRaw)

        self.imgRawJoueurs = {
                'vert': [ 
                         "MiniJeux/FrogMouches/images/grenouille-verte-e.png",
                         "MiniJeux/FrogMouches/images/grenouille-verte-o.png",
                         "MiniJeux/FrogMouches/images/grenouille-verte-n.png"
                         ],
                'jaune':[ 
                         "MiniJeux/FrogMouches/images/grenouille-jaune-e.png", 
                         "MiniJeux/FrogMouches/images/grenouille-jaune-o.png",
                         "MiniJeux/FrogMouches/images/grenouille-jaune-n.png"
                         ],
                'bleu':[  
                        "MiniJeux/FrogMouches/images/grenouille-bleue-e.png", 
                        "MiniJeux/FrogMouches/images/grenouille-bleue-o.png",
                        "MiniJeux/FrogMouches/images/grenouille-bleue-n.png"
                        ],
                'rouge':[  
                         "MiniJeux/FrogMouches/images/grenouille-rouge-e.png", 
                         "MiniJeux/FrogMouches/images/grenouille-rouge-o.png",
                         "MiniJeux/FrogMouches/images/grenouille-rouge-n.png"
                         ]
                }
        self.imgJoueurs = {}
        for i in self.imgRawJoueurs.items():
            self.imgRawJoueurs[i[0]] = []
            self.imgJoueurs[i[0]] = []
            for j in i[1]:
                image = Image.open(j)
                self.imgRawJoueurs[i[0]].append(image)
                self.imgJoueurs[i[0]].append(ImageTk.PhotoImage(image))

        self.imgRawElems = {
                            Plateforme:"MiniJeux/FrogMouches/images/Plateforme.png", 
                            Mouche:"MiniJeux/FrogMouches/images/Mouche.png",
                            Feu:"MiniJeux/FrogMouches/images/fire.png", 
                            PlateformeEquipe:"MiniJeux/FrogMouches/images/PlateformeEquipe.png",
                            Pow:"MiniJeux/FrogMouches/images/powi.png",
                            Pow2:"MiniJeux/FrogMouches/images/powa.png"
        }
        self.imgElems = {}
        
        for i in self.imgRawElems.items():
            self.imgRawElems[i[0]] = Image.open(i[1])
            self.imgElems[i[0]] = ImageTk.PhotoImage(self.imgRawElems.get(i[0]))

        self.largeurUnite = 0
        self.hauteurUnite = 0
        self.nextUpdate = -1

        self.ancienneHauteur = 0
        #self.setDimensions(controleur.pdj)
        self.canvas.pack()
    
    def start(self):
        self.actif = True
        self.listenersDeTouches = [
                                self.bind_all("<Up>", lambda x:self.deplacement(True,HAUT)),
                                self.bind_all("<Down>", lambda x:self.deplacement(True,BAS)),
                                self.bind_all("<Right>", lambda x:self.deplacement(True,DROITE)),
                                self.bind_all("<Left>", lambda x:self.deplacement(True,GAUCHE)),
                                self.bind_all("<KeyRelease-Up>", lambda x:self.deplacement(False,HAUT)),
                                self.bind_all("<KeyRelease-Down>", lambda x:self.deplacement(False,BAS)),
                                self.bind_all("<KeyRelease-Right>", lambda x:self.deplacement(False,DROITE)),
                                self.bind_all("<KeyRelease-Left>", lambda x:self.deplacement(False,GAUCHE))
                            ]
        self.nextUpdate = self.after(1, lambda  : self.dessinerMap(self.controleur.jdm, True));
        
            
        
    def deplacement(self, status, dir):
        self.controleur.deplacement(status, dir)

    def pause(self):
        self.actif = False

    def setDimensions(self, jeuDeMouches):
        """ M�thode qui doit �tre apell�e lorsque la vue doit �tre redimensionn�e 
        ou lorsque l'on modifie la grandeur. Elle calcule les unit�s de distance et 
        redimensionne les sprites � partir d'un JeuDeMouches. """
        self.largeurUnite = (self.largeur/jeuDeMouches.getLargeur())
        self.hauteurUnite = self.hauteur/jeuDeMouches.getHauteur()
        self.ancienneHauteur = jeuDeMouches.getHauteur()
        joueur = jeuDeMouches.getJoueurs().values()[0]
    
        for i in self.imgJoueurs.items():
            width = int(self.largeurUnite * joueur.largeur)
            height = int(self.hauteurUnite * joueur.hauteur)
            self.imgJoueurs[i[0]] = []
            c = 0
            for j in i[1]:
                image = self.imgRawJoueurs[i[0]][c].resize((width,height), Image.ANTIALIAS)
                self.imgJoueurs[i[0]].append(ImageTk.PhotoImage(image))
                c+=1
            
        for i in self.imgElems.items():
            width = int(self.largeurUnite * i[0].largeur + 1)
            height = int(self.hauteurUnite * i[0].hauteur + 1)
            self.imgRawElems[i[0]] = self.imgRawElems[i[0]].resize((width,height), Image.ANTIALIAS)
            self.imgElems[i[0]] = ImageTk.PhotoImage(self.imgRawElems.get(i[0]))

        self.canvas.config(width=int(self.largeurUnite*jeuDeMouches.getLargeur()))

    def dessinerMap(self, jeuDeMouches, repeat =  False):
        """ Cette m�thode redessine tout le canvas � partir d'un JeuDeMouche. """
        if not jeuDeMouches.isActif():
            self.actif = False
            return
        
        largeurUnite = self.largeurUnite
        hauteurUnite = self.hauteurUnite
        hauteur = jeuDeMouches.getHauteur()
        if hauteur != self.ancienneHauteur:
            self.setDimensions(jeuDeMouches)

        try:
            #Tout effacer sur la canvas
            self.canvas.delete(ALL)
            self.canvas.config(background="#8FACB9")
            self.canvas.create_image(self.largeur/2,self.hauteur/2, image=self.background)
            
            self.canvas.create_text(self.largeur/2,self.hauteur/2, text=str(int(jeuDeMouches.getTempsFin() - jeuDeMouches.getElapsedTime())), fill="gray", font=("Times", str(hauteurUnite*10), "bold"))
            
            for el in jeuDeMouches.getElemStatiques():
                if(isinstance(el,Plateforme)):
                    for j in range(el.largeur):
                        for i in range(el.hauteur):
                            self.canvas.create_image((el.pos.x+j+0.5)*largeurUnite, (hauteur-el.pos.y-i-el.hauteur/2.0)*hauteurUnite, image=self.imgElems[el.__class__])
                elif isinstance(el,PlateformeEquipe):
                    self.canvas.create_image((el.pos.x+(el.largeur/2.0))*largeurUnite, ((hauteur-el.pos.y-el.hauteur/2.0))*hauteurUnite,image=self.imgElems[el.__class__])
                    self.canvas.create_text((el.pos.x+el.largeur/2)*largeurUnite,(hauteur-el.pos.y-el.hauteur/2)*hauteurUnite, text=str(el.equipe.getScore()), fill="black", font=("Times", str(hauteurUnite*2), "bold"))
                elif isinstance(el,Pow) or isinstance(el,Pow2):
                    if el.isActive():
                        self.canvas.create_image((el.pos.x+(el.largeur/2.0))*largeurUnite, ((hauteur-el.pos.y-el.hauteur/2.0))*hauteurUnite,image=self.imgElems[Pow2])
                    else:
                        self.canvas.create_image((el.pos.x+(el.largeur/2.0))*largeurUnite, ((hauteur-el.pos.y-el.hauteur/2.0))*hauteurUnite,image=self.imgElems[Pow])
                else:
                    self.canvas.create_image((el.pos.x+(el.largeur/2.0))*largeurUnite, ((hauteur-el.pos.y-el.hauteur/2.0))*hauteurUnite,image=self.imgElems[el.__class__])
            
            for el in jeuDeMouches.getElemVariables():
                self.canvas.create_image((el.pos.x+(el.largeur/2.0))*largeurUnite, (hauteur-el.pos.y-el.hauteur/2.0)*hauteurUnite,image=self.imgElems[el.__class__])
            
            #Dessiner les joueurs
            for joueur in jeuDeMouches.getJoueurs().values():
                if joueur.direction == "GAUCHE":
                    img = self.imgJoueurs[joueur.couleur][1]
                else:
                    img = self.imgJoueurs[joueur.couleur][0]
                
                self.canvas.create_image((joueur.pos.x+(joueur.largeur/2.0))*largeurUnite, (hauteur-joueur.pos.y-joueur.hauteur/2.0)*hauteurUnite,image=img)
                
                self.canvas.create_text((joueur.pos.x+joueur.largeur/2)*largeurUnite,(hauteur-joueur.pos.y-joueur.hauteur)*hauteurUnite-hauteurUnite/2, text=str(joueur.score), fill="white", font=("Times", str(hauteurUnite), "bold"))

        except TclError:
            pass
        finally:
            if self.actif and repeat:
                self.nextUpdate = self.after(50, lambda  : self.dessinerMap(jeuDeMouches, True))

class Pow2(Pow):
    pass